O analisador semântico transforma as árvores sintáticas
em informação estruturada pela interpretação dessa estrutura. Para conseguir
esse objetivo, o analisador semântico trata cada parte da estrutura das árvores
e os \emph{tokens} produzidos.

\begin{figure}[h]
\centering
\includegraphics[width=0.75\textwidth]{imagens/implementacao/funcionamento_semantico.png}
\caption{Analisador Semântico e Gerador da Estrutura}
\end{figure}

As árvore sintáticas são pecorridas usando o algoritmo de pré-ordem que pega o
nó raiz da árvore e em seguida o nó da folha da esquerda e percorre todos os nós
até o nó da folha da direita. Isso é importante pois, na língua
portuguesa escrita, seguimos o padrão de escrever da esquerda para a direita,
tanto na ordem de escrita das palavras quanto na ordem de escrita das frases.

\begin{figure}[h]
\centering
\includegraphics[width=0.25\textwidth]{imagens/implementacao/arvore-resultado.png}
\caption{Exemplo de árvore de RESULTADO}
\end{figure}

O objetivo de verificar o nó da raiz é verificar qual estrutura é
analisada. No caso da árvore de RESULTADO podemos verificar facilmente o
resultado do jogo, pois vem no formato ``1 a 1'', ``1 x 1'' ou ``1 - 1''.

No caso da estrutura sintática RESULTADO\underline{  }EXPLICITO a vantangem
é maior ainda, pois temos as equipes e o resultado em uma estrutura de fácil
reconhecimento, como em ``Palmeiras 1 X 0 Barueri''. Com isso, podemos preencher
a estrutura de dados com os dados imediatamente.

Para o caso que não ter estrutura, ao pecorrer as folhas das árvores, o
analisador pega o \emph{token} com a sua classificação e, ao achar uma
equipe, preenche as equipes da estrutura de dados \textbf{JogoDeFutebol} a
medida que é encontrado no texto. Esse método se mostrou eficiente, pois
normalmente as equipes que jogaram a partida são as primeiras citadas no texto.

Com esse método pegamos as equipes, o resultado e o estádio onde ocorreu a
partida. Normalmente, apenas com esse processamento, a maioria dos dados seria
preenchida. Entretando, como a retirada apenas da primeira ocorrência
de equipes está sujeita a muitos erros, como pegar equipes que não jogaram a
partida, foram citadas no texto antes de alguma que realmente jogou a partida.

Na segunda parte do processamento semântico é feita uma análise estatística que
utiliza as quantidade de citações no texto.

Para garantir que essas equipes selecionadas são as corretas, o analisador
semântico guarda qualquer referência de equipe encontrada. No final, ele conta
as referências achadas de equipes e compara com as encontradas pelo primeiro
processamento. Confirmadas as referências, são gravadas na estrutura de dados;
caso não, são trocadas pelas referências mais achadas. Assim, temos um contator
de referências às equipes.

Todas essas informações são gravadas em uma estrutura de dados que chamamos de
\textbf{JogoDeFutebol}, que contém o nome das duas equipes, os gols das
equipes no jogo, o estádio e a data do jogo. Podemos ver isso no código abaixo:

\begin{verbatim}
    jogoDeFutebol = {'equipe1':'',
                     'equipe2':'',
                     'gols1':0,
                     'gols2':0,
                     'estadio':'',
                     'data':''}
\end{verbatim}

Assim, na primeira parte da conferência, é verificado se as duas equipes mais
referenciadas são as equipes que foram encontradas na busca inicial. Parte-se do
princípio que as duas equipes que jogaram a partida são as mais referênciadas no texto, 
pois outras equipes também são referenciadas por causa
de jogos anteriores ou futuros.

Podemos ver isso no algoritmo abaixo:

\begin{verbatim}
if self.jogoDeFutebol['equipe1'] == equipePrimeira 
         and self.jogoDeFutebol['equipe2'] <> equipeSegunda:
   self.jogoDeFutebol['equipe2'] = equipeSegunda
elif self.jogoDeFutebol['equipe1'] <> equipePrimeira 
         and self.jogoDeFutebol['equipe2'] == equipeSegunda:
   self.jogoDeFutebol['equipe1'] = equipePrimeira
elif self.jogoDeFutebol['equipe1'] == equipeSegunda 
         and self.jogoDeFutebol['equipe2'] <> equipePrimeira:
   self.jogoDeFutebol['equipe2'] = equipePrimeira        
elif self.jogoDeFutebol['equipe1'] <> equipeSegunda 
         and self.jogoDeFutebol['equipe2'] == equipePrimeira:
   self.jogoDeFutebol['equipe1'] = equipeSegunda
elif self.jogoDeFutebol['equipe1'] <> equipeSegunda 
         and self.jogoDeFutebol['equipe2'] <> equipePrimeira 
         and self.jogoDeFutebol['equipe1'] <> equipePrimeira 
         and self.jogoDeFutebol['equipe2'] <> equipeSegunda:
   self.jogoDeFutebol['equipe1'] = equipePrimeira
   self.jogoDeFutebol['equipe2'] = equipeSegunda
\end{verbatim}

Caso a \emph{equipe1} da estrutura de dados JogoDeFutebol seja igual a equipe
mais referenciada, verifica se a \emph{equipe2} é igual a segunda mais
referenciada. Caso não seja, há a troca. Caso a \emph{equipe1} é igual a segunda
mais referenciada, verifica se a \emph{equipe2} é igual a primeira mais
referenciada. Esse algoritmo é analogamente aplicado, executando primeiro a
verificação da \emph{equipe2}. Esse princípio é muito importante, pois são
verificadas as equipes pela quantidade de vezes que elas aparecem no texto. 

O mais importante é o caso de nenhuma das equipes forem
escolhidas entre as mais referenciadas, pois, pelo nosso algoritmo, elas
são totalmente descartadas e trocadas para as mais referenciadas. A partir disso, 
a análise semântica vai para a próxima fase, que é a procura de
relações entre as equipes pela busca de construções sintáticas de frases.

Levando em consideraćão que o analisador semântico ache uma árvore que contenha
a estrutura FUTEBOL, ele verifica essa árvore pela unidade do verbo. Caso o
verbo seja relacionado aos verbos \textit{empatar}, \textit{vencer} ou
\textit{derrotar}, o analisador vai procurar no sintagma nominal as duas equipes
e armazenar em outra estrutura, que é chamamada de \textbf{relacao}.

\begin{figure}[h]
\centering
\includegraphics[width=0.5\textwidth]{imagens/implementacao/futebol-arvore.png}
\caption{Exemplo de Árvore de FUTEBOL}
\end{figure}

Código da estrutura de relação entre equipes:

\begin{verbatim}
    relacao = {'equipe1':'',
               'relacao':'',
               'equipe2':''}
\end{verbatim}

Essa estrutura é utilizada para corrigir eventuais
erros que são preenchidos na estrutura \textbf{JogoDeFutebol}, pois a estrutura
\textbf{JogoDeFutebol} pode ser preenchida por equipes erradas pelos dois
processamento citados anteriormente, ou o resultado pode estar com valor
trocado; ou seja, a equipe vitoriosa pode ser marcada com os gols da
equipe derrotada.

Encontrada uma relação entre as equipes, é verificado se as
equipes estão corretas, ou seja, se as equipes de \textbf{JogoDeFutebol} são as
mesmas de \textbf{Relacao}. Caso não estejam, faz-se a troca. Podemos ver isso
no algoritmo abaixo:

\begin{verbatim}
if len(self.relacao['relacao']) > 0:
   if self.jogoDeFutebol['equipe1'] == self.relacao['equipe1']:
      if self.jogoDeFutebol['equipe2'] <> self.relacao['equipe2'] 
                and len(self.relacao['equipe2']) > 0:                   
         self.jogoDeFutebol['equipe2'] = self.relacao['equipe2']
    elif self.jogoDeFutebol['equipe2'] == self.relacao['equipe2']:
      if self.jogoDeFutebol['equipe1'] <> self.relacao['equipe1'] 
               and len(self.relacao['equipe1']) > 0:
         self.jogoDeFutebol['equipe1'] = self.relacao['equipe1']
    elif len(self.relacao['equipe2']) >0 and len(self.relacao['equipe1'])>0:
       self.jogoDeFutebol['equipe1'] = self.relacao['equipe1']
       self.jogoDeFutebol['equipe2'] = self.relacao['equipe2']
\end{verbatim}

Nesse código é verificado se a \emph{equipe1} da estrutrura
\textbf{JogoDeFutebol} é igual a \emph{equipe1} da estrutura \textbf{relacao}; verifica-se também se
a \emph{equipe2} é diferente nas duas estruturas. Caso seja, faz-se a troca.
Assim, o acerto do extrator é incrementado ao descobrir as equipes corretas. Analogamente, é feito
com a \emph{equipe2} e, caso as equipes da estrutrura \textbf{JogoDeFutebol}
forem totalmente diferentes de \textbf{relacao} e \textbf{relacao} tiver as duas
equipes preenchidas, então essas duas equipes têm prioridades de
escolha, sendo substituídas em \textbf{JogoDeFutebol}.

Para verificar se os gols atribuídos às equipes forem corretos (a equipe
vitoriosa fez mais gols e a derrotada, menos) é verificada a relação e a
quantidade de gols atribuída à equipe. Assim, temos o código:

\begin{verbatim}
if self.relacao['relacao'] == 'venceu' or self.relacao['relacao'] == 'vence' 
            or self.relacao['relacao'] == 'goleia' 
            or self.relacao['relacao'] == 'derruba':
    if self.relacao['equipe1'] == self.jogoDeFutebol['equipe1']:
      if int(self.jogoDeFutebol['gols1']) < int(self.jogoDeFutebol['gols2']):
         temp = self.jogoDeFutebol['gols1']
         self.jogoDeFutebol['gols1'] = self.jogoDeFutebol['gols2']
         self.jogoDeFutebol['gols2'] = temp
elif self.relacao['equipe1'] == self.jogoDeFutebol['equipe2']:
        temp = self.jogoDeFutebol['gols1']
        self.jogoDeFutebol['gols1'] = self.jogoDeFutebol['gols2']
        self.jogoDeFutebol['gols2'] = temp
\end{verbatim}

No caso de vitória, se a \emph{equipe1} que venceu (ou seja, a relação são
verbos de vitória) tem menos gols, eles são invertidos entre as equipes e, se
foram invertidos os nomes das equipes na estrutura de dados
\textbf{JogoDeFutebol} e \textbf{relacao}, os gols também serão invertidos.
Analogamente é feito dessa maneira caso haja derrota da equipe1.

No caso de empate entre as equipes se os gols não forem
iguais, é atribuído o valor `0' aos gols de ambas as equipes, o que pelo menos
ameniza o erro de uma empate com uma equipe com mais gols. Essa forma de análise 
mostrou que o número de erros que o
analisador semântico gerou diminuiu em relação à busca apenas estatística.

Assim, conseguimos fazer o objetivo do Extrator, que é a extraćão dos dados mais
importantes de uma partida e futebol; que são as equipes, o resultado e as
partidas.
